export async function calculateProvinceScores(provinces) {
  // 初始化结果对象
  const result = {
    national: {
      GDP: 0,
      employment: 0,
      income: 0,
      livingCost: 0,
      education: 0,
    },
    provinces: [],
  };

  // 获取最新年份的数据
  const latestYear = Math.max(
    ...provinces.flatMap(
      (p) =>
        p.statistics
          .find((s) => s.name === "GDP")
          ?.yearlyData.map((d) => d.year) || []
    )
  );

  // 计算各项指标的最大值和最小值，用于归一化
  const indicators = {
    GDP: calculateIndicatorStats(provinces, "GDP"),
    income: calculateIndicatorStats(provinces, "income"),
    cost: calculateIndicatorStats(provinces, "cost"),
    edFund: calculateIndicatorStats(provinces, "edFund"),
  };

  // 计算每个省份的评分
  for (const province of provinces) {
    try {
      const provinceScore = {
        name: province.name,
        scores: {
          GDP: calculateGDPScore(province, indicators.GDP),
          employment: calculateEmploymentScore(province),
          income: calculateIncomeScore(province, indicators.income),
          livingCost: calculateLivingCostScore(province, indicators.cost),
          education: calculateEducationScore(province, indicators.edFund),
        },
      };

      // 确保所有分数都是有效数字
      Object.keys(provinceScore.scores).forEach((key) => {
        if (isNaN(provinceScore.scores[key])) {
          provinceScore.scores[key] = 0;
        }
      });

      result.provinces.push(provinceScore);
    } catch (error) {
      console.error(`计算省份 ${province.name} 的评分时出错:`, error);
      result.provinces.push(createDefaultScore(province.name));
    }
  }

  // 计算全国平均分
  calculateNationalAverage(result);

  return result;
}

// 计算指标的统计信息
function calculateIndicatorStats(provinces, indicatorName) {
  const values = provinces.flatMap(
    (p) =>
      p.statistics
        .find((s) => s.name === indicatorName)
        ?.yearlyData.filter((d) => d.value > 0)
        .map((d) => d.value) || []
  );

  return {
    max: Math.max(...values),
    min: Math.min(...values),
    avg: values.reduce((sum, val) => sum + val, 0) / values.length,
  };
}

/**
 * GDP得分计算
 *
 * 得分 = ((平均GDP - 最小GDP) / (最大GDP - 最小GDP)) * 100
 * 平均GDP = 所有年份GDP总和 / 年份数量
 */
function calculateGDPScore(province, stats) {
  const gdpStats =
    province.statistics.find((s) => s.name === "GDP")?.yearlyData || [];
  if (gdpStats.length === 0) return 0;

  // 获取最近几年的GDP数据
  const recentGDP = gdpStats
    .filter((stat) => stat.value > 0)
    .sort((a, b) => b.year - a.year);

  if (recentGDP.length === 0) return 0;

  // 计算平均GDP
  const avgGDP =
    recentGDP.reduce((sum, stat) => sum + stat.value, 0) / recentGDP.length;

  // 归一化得分
  return normalizeScore((avgGDP - stats.min) / (stats.max - stats.min));
}

/**
 * 将给定的值标准化为0到100之间的分数
 * 如果值不是数字或无法精确表示，则返回0
 * 此函数确保了分数的合理性和标准化，避免了过小或过大的值造成的影响
 *
 * @param {number} value - 需要被标准化的分数值
 * @returns {number} - 位于0到100之间的整数，代表标准化后的分数
 */
function normalizeScore(value) {
  // 检查value是否为非数字或无法精确表示的数字，如果是，则返回0
  if (isNaN(value) || !isFinite(value)) {
    return 0;
  }

  // 将value转换为百分制分数，确保结果在0到100之间
  return Math.max(0, Math.min(100, Math.round(value * 100)));
}

/**
 * 收入得分计算
 *
 * 得分 = ((平均收入 - 最小收入) / (最大收入 - 最小收入)) * 100
 * 其中：平均收入 = 所有年份收入总和 / 年份数量
 */
function calculateIncomeScore(province, stats) {
  const incomeStats =
    province.statistics.find((s) => s.name === "income")?.yearlyData || [];
  if (incomeStats.length === 0) return 0;

  // 获取最近几年的收入数据
  const recentIncome = incomeStats
    .filter((stat) => stat.value > 0)
    .sort((a, b) => b.year - a.year);

  if (recentIncome.length === 0) return 0;

  // 计算平均收入
  const avgIncome =
    recentIncome.reduce((sum, stat) => sum + stat.value, 0) /
    recentIncome.length;

  // 归一化得分
  return normalizeScore((avgIncome - stats.min) / (stats.max - stats.min));
}

//
/**
 * 生活成本得分计算（消费支出越低分数越高）
 *
 * 得分 = (1 - (平均消费支出 - 最小消费) / (最大消费 - 最小消费)) * 100
 * 其中：
 * - 平均消费支出 = 所有年份消费支出总和 / 年份数量
 * - 消费支出越低，得分越高（所以用1减）
 */
function calculateLivingCostScore(province, stats) {
  const costStats =
    province.statistics.find((s) => s.name === "cost")?.yearlyData || [];
  if (costStats.length === 0) return 0;

  // 获取最近几年的消费支出数据
  const recentCost = costStats
    .filter((stat) => stat.value > 0)
    .sort((a, b) => b.year - a.year);

  if (recentCost.length === 0) return 0;

  // 计算平均消费支出
  const avgCost =
    recentCost.reduce((sum, stat) => sum + stat.value, 0) / recentCost.length;

  // 消费支出越低分数越高，所以用反向计算
  return normalizeScore(1 - (avgCost - stats.min) / (stats.max - stats.min));
}

/**
 * 教育资源得分计算
 *
 * 教育投入比例 = 教育经费（万元）/ GDP（万元）* 100%
 * 设定标准：
 * - 优秀水平：10%
 * - 及格水平：4%（国际教育投入标准）
 */
function calculateEducationScore(province, stats) {
  const edFundStats =
    province.statistics.find((s) => s.name === "edFund")?.yearlyData || [];
  const gdpStats =
    province.statistics.find((s) => s.name === "GDP")?.yearlyData || [];

  if (edFundStats.length === 0 || gdpStats.length === 0) return 0;

  // 计算最近几年的教育投入比例
  const eduInvestmentRatios = edFundStats
    .filter((stat) => {
      const gdp = gdpStats.find((g) => g.year === stat.year);
      return stat.value > 0 && gdp && gdp.value > 0;
    })
    .map((stat) => {
      const gdp = gdpStats.find((g) => g.year === stat.year);
      // 将GDP转换为万元（1亿=10000万），然后计算比例
      const gdpInWan = gdp.value * 10000;
      // 计算教育经费占GDP的百分比
      const ratio = (stat.value / gdpInWan) * 100;
      return {
        year: stat.year,
        ratio: ratio,
      };
    })
    .sort((a, b) => b.year - a.year);

  if (eduInvestmentRatios.length === 0) return 0;

  // 计算平均教育投入比例
  const avgEduInvestmentRatio =
    eduInvestmentRatios.reduce((sum, item) => sum + item.ratio, 0) /
    eduInvestmentRatios.length;

  // 设定评分标准
  const excellentStandard = 20; // 20%
  const passStandard = 4; // 4% - 国际教育投入标准

  // 计算得分
  let score;
  if (avgEduInvestmentRatio >= excellentStandard) {
    score = 100; // 达到或超过国际标准
  } else if (avgEduInvestmentRatio <= passStandard) {
    // 低于及格线，按比例计算0-60分
    score = Math.max(0, (avgEduInvestmentRatio / passStandard) * 60);
  } else {
    // 介于及格和优秀之间，按比例计算60-100分
    score =
      60 +
      ((avgEduInvestmentRatio - passStandard) /
        (excellentStandard - passStandard)) *
        40;
  }

  return Math.round(score);
}

/**
 * 计算就业机会评分（基于就业率）
 * 
 * 就业率 = 就业人数 / 劳动年龄人口 * 100%
 * 设定标准：
 * - 优秀水平：95%（接近充分就业）
 * - 及格水平：50%（基本就业水平）
 * 
 * 注：使用劳动年龄人口（16-64岁）作为基数，假设劳动年龄人口约占总人口的60%
 * 一般发达地区就业率在85%-95%之间
 */
function calculateEmploymentScore(province) {
  const employmentStats = province.statistics.find(s => s.name === "employment")?.yearlyData || [];
  const populationStats = province.statistics.find(s => s.name === "population")?.yearlyData || [];

  if (employmentStats.length === 0 || populationStats.length === 0) return 0;

  // 获取有效的就业率数据
  const employmentRates = employmentStats
    .filter(stat => {
      const population = populationStats.find(p => p.year === stat.year);
      return stat.value > 0 && population && population.value > 0;
    })
    .map(stat => {
      const population = populationStats.find(p => p.year === stat.year);
      // 假设劳动年龄人口约占总人口的60%
      const workingAgePopulation = population.value * 0.6;
      // 计算就业率百分比
      const rate = (stat.value / workingAgePopulation) * 100;
      return {
        year: stat.year,
        employment: stat.value,
        population: population.value,
        workingAgePopulation,
        rate: rate
      };
    })
    .sort((a, b) => b.year - a.year);

  if (employmentRates.length === 0) return 0;

  // 计算平均就业率
  const averageRate = 
    employmentRates.reduce((sum, item) => sum + item.rate, 0) / 
    employmentRates.length;

  // 设定评分标准
  const excellentStandard = 95;  // 95% - 接近充分就业
  const passStandard = 50;       // 50% - 基本就业水平

  // 计算得分
  let score;
  if (averageRate >= excellentStandard) {
    score = 100;  // 达到或超过优秀标准
  } else if (averageRate <= passStandard) {
    // 低于及格线，按比例计算0-60分
    score = Math.max(0, (averageRate / passStandard) * 60);
  } else {
    // 介于及格和优秀之间，按比例计算60-100分
    score = 60 + ((averageRate - passStandard) / 
           (excellentStandard - passStandard)) * 40;
  }

  return Math.round(score);
}

// 创建默认评分
function createDefaultScore(provinceName) {
  return {
    name: provinceName,
    scores: {
      GDP: 0,
      employment: 0,
      income: 0,
      livingCost: 0,
      education: 0,
    },
  };
}

// 计算全国平均分
function calculateNationalAverage(result) {
  const validProvinces = result.provinces.filter((p) =>
    Object.values(p.scores).every((score) => !isNaN(score))
  );

  if (validProvinces.length > 0) {
    Object.keys(result.national).forEach((field) => {
      const sum = validProvinces.reduce((acc, p) => acc + p.scores[field], 0);
      result.national[field] = Math.round(sum / validProvinces.length);
    });
  }
}
